#define _CRT_SECURE_NO_WARNINGS 1
//#include <iostream>
//using namespace std;
//
//class Date
//{
//public:
//	////无参构造函数
//	//Date()
//	//{
//	//	_year = 1;
//	//	_month = 1;
//	//	_day = 1;
//	//}
//
//	////有参构造函数
//	//Date(int year, int month, int day)
//	//{
//	//	_year = year;
//	//	_month = month;
//	//	_day = day;
//	//}
//
//	//全缺省构造函数
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//
//		_a = (int*)malloc(sizeof(int));
//		if (_a == nullptr)
//		{
//			perror("malloc fail");
//			return;
//		}
//
//		cout << _day << "Date()" << endl;
//	}
//
//	//析构函数
//	~Date()
//	{
//		//清理操作
//		free(_a);
//		_a = nullptr;
//
//		cout << _day << "~Date()" << endl;
//	}
//
//	void Show() const
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//	//拷贝构造函数
//	Date(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//		_a = (int*)malloc(sizeof(int));
//	}
//
//	friend bool operator==(const Date& d1, const Date& d2);
//
//
//	//ostream& operator<<(ostream& output)
//	//{
//	//	//……
//	//}
//
//	friend ostream& operator<<(ostream& output, const Date& d);
//	friend istream& operator>>(istream& input, const Date& d);
//
//	Date& operator=(const Date d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//
//		return *this;
//	}
//
//	void show1()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//	Date* operator&()
//	{
//		//return this;
//		return nullptr;
//	}
//
//	const Date* operator&() const
//	{
//		//return this;
//		return nullptr;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//	int* _a;
//};
//
//bool operator==(const Date& d1, const Date& d2)
//{
//	if (d1._day == d2._day
//		&& d1._month == d2._month
//		&& d1._year == d2._year)
//	{
//		return true;
//	}
//	return false;
//}
//
//ostream& operator<<(ostream& output, const Date& d)
//{
//	output << d._year << "/" << d._month << "/" << d._day << endl;
//
//	return output;
//}
//istream& operator>>(istream& input, const Date& d)
//{
//	cout << "请依次输入年月日：->";
//	cin >> d._year >> d._month >> d._day;
//
//	return input;
//}
//
//int main()
//{
//	Date d1(2024, 9, 3);
//	Date d2;
//
//	d2 = d1;
//
//	return 0;
//}
//
////int main()
////{
////	Date d1(2024, 9, 3);
////	d1.Show();
////
////	const Date d2(2024, 9, 1);
////	d2.Show();
////
////	//d2.show1();
////
////	return 0;
////}
//
////int main()
////{
////	Date d1(2024,9,3);
////	Date d2;
////
////	d2 = d1;//调用拷贝构造
////
////	Date d3;
////	Date d4;
////	Date d5;
////
////	d5 = d4 = d3 = d1;//可以连续赋值
////
////	Date d6 = d1;//不是赋值运算符重载，而是拷贝构造
////
////	return 0;
////}
//
////int main()
////{
////	Date d1;
////	Date d2;
////	Date d3;
////
////	cin >> d1 >> d2 >> d3;
////
////	cout << d1 << d2 << d3 << endl;
////
////	return 0;
////}
//
////int main()
////{
////	Date d(2024, 9, 2);
////
////	//cout << d;
////
////	//d << cout;
////
////	return 0;
////}
//
////ostream& operator<<(ostream& output, const Date& d)
////{
////	//……
////}
//
////ostream& operator<<(const Date& d)
////{
////	//……
////}
////
////ostream& operator<<(ostream& output)
////{
////	//……
////}
//
////int main()
////{
////	Date d1(2024, 9, 2);
////	Date d2(2024, 9, 1);
////
////	//d1传给d1，d2传给d2
////	Date operator+(const Date & d1, const Date & d2)
////	d1 + d2;
////
////	//d1传给this，d2传给d
////	Date operator+(const Date & d)
////	d1 + d2;
////
////	//前置++
////	//d1传给this
////	Date operator++();
////	++d1;
////
////	return 0;
////}
//
////int main()
////{
////	Date d1(1,1,1);
////	Date d2(2,2,2);
////	Date d3(3,3,3);
////	Date d4(4,4,4);
////
////	Date d5(d4);
////	Date d6 = d4;
////
////	return 0;
////}
//
//
////int main()
////{
////	//无参构造函数
////	Date d1;
////	d1.Show();
////
////	//带参构造函数
////	Date d2(2024, 8, 31);
////	d2.Show();
////
////	//全缺省构造函数
////	Date d3;
////	Date d4(2024);
////	Date d5(2024,8);
////	Date d6(2024,8,31);
////
////	return 0;
////}
//
//////运算符重载
//////返回值 operator运算符(形参表)
////Date operator+(const Date& d1, const Date& d2)
////{
////	//……
////}
//
////Date opertaor++(int);//后置++
////Date operator++();//前置++

//class Date
//{
//public:
//	/*Date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}*/
//
//	Date(int year, int month, int day): 
//		_year(year), _month(month), _day(day) {}
//
//	Date(int year, int month, int day) :
//		_day(day),_month(month),_year(year) {}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};

//int main()
//{
//	/*int& a;*/
//
//	const int a;
//	a = 1;
//}

//#include <iostream>
//using namespace std;
//
//class A
//{
//public:
//	A(int ii):
//		_a1(ii){}
//
//	void Print()
//	{
//		cout << _a1 << "/" << _a2 << endl;
//	}
//private:
//	int _a2 = 1;
//	int _a1 = 1;
//};
//
//int main()
//{
//	int ii = 1;
//	A a(ii);
//
//	a.Print();
//
//	return 0;
//}


//#include <iostream>

//void Print();//函数声明
//
//class A
//{
//	friend void Print(const A& a);//只是一种访问权限的声明，表明Print函数可以访问该类的私有成员
//public:
//	//friend void Print(const A& a);
//	A(int a,int b):
//		_a(a),_b(b)
//	{}
//
//private:
//	//friend void Print(const A& a);
//	int _a;
//	int _b;
//};
//
//void Print(const A& a)
//{
//	std::cout << a._a << " " << a._b << std::endl;
//}
//
//int main()
//{
//	A a(1, 2);
//
//	Print(a);
//
//	return 0;
//}

//前置声明
//class A;
//
//class B
//{
//public:
//	void Print(const A& a)
//	{
//		std::cout << a._a << " " << a._b << std::endl;
//	}
//};
//
//class A
//{
//	friend void B::Print(const A& a);
//public:
//	A(int a, int b) :
//		_a(a), _b(b)
//	{}
//
//private:
//	int _a;
//	int _b;
//};
//
//
////void B::Print(const A& a)
////{
////	std::cout << a._a << " " << a._b << std::endl;
////}
//
//int main()
//{
//	A a(1, 10);
//
//	return 0;
//}

////前置声明
//class B;
//
//class A
//{
//	friend void Print(const A& a, const B& b);
//private:
//	int _a;
//	int _b;
//};
//
//class B
//{
//	friend void Print(const A& a, const B& b);
//private:
//	char _a;
//	char _b;
//};
//
//void Print(const A& a, const B& b)
//{
//	std::cout << a._a << " " << a._b << std::endl;
//	std::cout << b._a << " " << b._b << std::endl;
//}


//class B
//{
//public:
//	class A
//	{
//		void Print(const B& b)
//		{
//			std::cout << b._a << " " << b._b << std::endl;
//		}
//	};
//private:
//	int _a;
//	int _b;
//};
//
//int main()
//{
//
//	//std::cout << sizeof(B) << std::endl;
//
//	return 0;
//}


//class B
//{
//public:
//	class A
//	{
//		void Print(const B& b)
//		{
//			std::cout << b._a << " " << b._b << std::endl;
//		}
//	};
//private:
//	int _a;
//	int _b;
//};
//
////上面相当于下面
//class A
//{
//	void Print(const B& b)
//	{
//		std::cout << b._a << " " << b._b << std::endl;
//	}
//};
//
//class B
//{
//public:
//	friend A;
//private:
//	int _a;
//	int _b;
//};

//class A
//{
//public:
//	A(int a,int b):
//		_a(a),_b(b)
//	{}
//
//private:
//	int _a;
//	int _b;
//};
//
//int main()
//{
//	A a(1,2);//有名对象
//	A(3,4);//无名对象
//
//	return 0;
//}

//class Solution
//{
//public:
//	int sum_Solution()
//	{
//		std::cout << "sum_Solution" << std::endl;
//	}
//private:
//	int _i;
//};
//
//int main()
//{
//	Solution s;
//	s.sum_Solution();
//
//	Solution().sum_Solution();
//
//	return 0;
//}\

//class A
//{
//public:
//	A(int a,int b):
//		_a(a),_b(b)
//	{}
//
//private:
//	int _a;
//	int _b;
//};
//
//int main()
//{
//	const A& a = A(1, 2);
//}

//class A
//{
//private:
//	static int _a;
//};
//
//int _a = 1;

//int main()
//{
//	std::cout << sizeof(A) << std::endl;
//
//	return 0;
//}\

#include <iostream>

//class A
//{
//public:
//	A(int b):
//		_b(b)
//	{}
//
//	//static void Show()
//	//{
//	//	std::cout << _a << std::endl;//正确
//	//	std::cout << _b << std::endl;//错误，静态成员函数不能访问非静态成员变量
//	//}
//
//	void Print()
//	{
//		std::cout << _a << std::endl;//正确，非静态成员函数可以访问静态成员变量
//		std::cout << _b << std::endl;//正确
//	}
//
////private:
//	static int _a;
//	int _b;
//};
//
//int A::_a = 1;
//
//int main()
//{
//	//静态成员变量
//	std::cout << A::_a << std::endl;
//
//	A a(10);
//	std::cout << a._a << std::endl;
//
//	//静态成员函数
//	A::Show();
//
//	A b(10);
//	b.Show();
//
//	return 0;
//}

//
//class A
//{
//public:
//	A(int a) :
//		_a(a)
//	{}
//
//	A(int a,int b):
//		_a(a),_b(b)
//	{}
//
//private:
//	int _a;
//	int _b;
//};
//
//int main()
//{
//	A a1(1);
//
//	//1会先隐式类型转换为A类型的临时变量，然后该临时变量在拷贝构造给a2
//	A a2 = 1;
//
//	//C++11之后支持多参数的转化
//	//但是必须用花括号括起来
//	A a3(1, 2);
//
//	A a4 = { 1,2 };
//	//A a5 = 1, 2;//错误
//
//	return 0;
//}


class A
{
public:
	A(int a = 1):
		_a(a)
	{
		std::cout << "A()" << std::endl;
	}

	A(const A& a)
	{
		_a = a._a;
		std::cout << "A(const)" << std::endl;
	}

	A& operator=(const A& a)
	{
		_a = a._a;
		std::cout << "operator+" << std::endl;
		return *this;
	}

private:
	int _a;
};

void f1(A a)
{}

void f2(const A& a)
{}

A f3()
{
	A aa(1);
	return aa;
}

int main()
{
	A aa;

	aa = f3();
}